Lecture Notes on Formal Program Development

This document was originally produced as lecture notes for the MSc and PG course ``Formal Program Development'' early in 1997. After some initial general considerations on this subject the paper focusses on the way one can use Extended ML (EML) for formal program development, which features EML contains and why, and which pitfalls one has to avoid when formally developing ML programs. Usage, features, and pitfalls are all presented through examples

The variable containment problem

The essentially free variables of a term $t$ in some $\lambda$-calculus, FV $_{\beta}(t)$, form the set ($x$ $_{\mid}^{\mid}$ $\forall u.t=_{\beta}u\Rightarrow x$ $\epsilon$ FV$(u)$}. This set is significant once we consider equivalence classes of $\lambda$-terms rather than $\lambda$-terms themselves, as for instance in higher-order rewriting. An important problem for (generalised) higher-order rewrite systems is the variable containment problem: given two terms $t$ and $u$, do we have for all substitutions $\theta$ and contexts $C$[] that FV$_{\beta}(C[t]^{\theta}) \supseteq$ FV$_{\beta}(C[u^{\theta}])$? This property is important when we want to consider $t \to u$ as a rewrite rule and keep $n$-step rewriting decidable. Variable containment is in general not implied by FV $_{\beta} (t)\supseteq$ FV$_{\beta}(u)$. We give a decision procedure for the variable containment problem of the second-order fragment of $\lambda^{\to}$. For full $\lambda^{\to}$ we show the equivalence of variable containment to an open problem in the theory of PCF; this equivalence also shows that the problem is decidable in the third-order case

Non-omega-overlapping TRSs are UN

This paper solves problem #79 of RTA’s list of open problems [14] — in the positive. If the rules of a TRS do not overlap w.r.t. substitutions of infinite terms then the TRS has unique normal forms. We solve the problem by reducing the problem to one of consistency for “similar” constructor term rewriting systems. For this we introduce a new proof technique. We define a relation ⇓ that is consistent by construction, and which — if transitive — would coincide with the rewrite system’s equivalence relation =R. We then prove the transitivity of ⇓ by coalgebraic reasoning. Any concrete proof for instances of this relation only refers to terms of some finite coalgebra, and we then construct an equivalence relation on that coalgebra which coincides with ⇓

Maximum-entropy theory of steady-state quantum transport

We develop a theoretical framework for describing steady-state quantum transport phenomena, based on the general maximum-entropy principle of nonequilibrium statistical mechanics. The general form of the many-body density matrix is derived, which contains the invariant part of the current operator that guarantees the nonequilibrium and steady-state character of the ensemble. Several examples of the theory are given, demonstrating the relationship of the present treatment to the widely used scattering-state occupation schemes at the level of the self-consistent single-particle approximation. The latter schemes are shown not to maximize the entropy, except in certain limits

Modularity of Convergence and Strong Convergence in Infinitary Rewriting

Properties of Term Rewriting Systems are called modular iff they are preserved under (and reflected by) disjoint union, i.e. when combining two Term Rewriting Systems with disjoint signatures. Convergence is the property of Infinitary Term Rewriting Systems that all reduction sequences converge to a limit. Strong Convergence requires in addition that redex positions in a reduction sequence move arbitrarily deep. In this paper it is shown that both Convergence and Strong Convergence are modular properties of non-collapsing Infinitary Term Rewriting Systems, provided (for convergence) that the term metrics are granular. This generalises known modularity results beyond metric \infty

Compilation of combinatory reduction systems

Combinatory Reduction Systems generalise Term Rewriting Systems. They are powerful enough to express β-reduction of λ-calculus as a single rewrite rule. The additional expressive power has its price — CRSs are much harder to implement than ordinary TRSs. We propose an abstract machine suitable for executing CRSs. We define what it means to execute an instruction, and give a translation from CRS rules into sequences of instructions. Applying a rewrite rule to a term is realised by initialising the machine with this term, and then successively executing the instructions of the compiled rule

Limits of ML-definability

It is well-known that the type system of ML is overly restrictive in its handling of recursion: certain intuitively sound emphterms do not pass ML's type-check. We formalise this intuition and show that the restriction is semantical: there are computable (semantical) emphfunctions which cannot be expressed by well-typed (syntactical) terms

About the completeness of type systems

The original purpose of type systems for programming languages was to prevent certain forms of run-time errors, like using a number as a function. Some type systems go as far as guaranteeing the absence of run-time errors, e.g. the type system of Standard ML. One can call such a type system ``sound''. This raises the question of the dual notion of completeness, i.e. is everything typable that does not have run-time errors? Or, to put it in another way: does the type system restrict the expressive power of the underlying implementation in an undesirable way? To make this rather vague idea precise we define an abstract notion of ``type system'', together with general notions of soundness and completeness. We examine several type systems for these properties, for instance ?? and PCF are both complete, but for very different reasons

Confluence of Curried Term-Rewriting Systems

Term rewriting systems operate on first-order terms. Presenting such terms in curried form is usually regarded as a trivial change of notation. However, in the absence of a type-discipline, or in the presence of a more powerful type-discipline than simply typed ?-calculus, the change is not as trivial as one might first think. It is shown that currying preserves confluence of em arbitrary/ term rewriting systems. The structure of the proof is similar to Toyama's proof that confluence is a modular property of TRS

Polymorphic Type Checking by Interpretation of Code

The type system of most modern functional programming languages is based on Milner's polymorphism. A compiler or interpreter usually checks (or infers) the types of functions and other values by directly inspecting the source code of a program. Here, another approach is taken: The program is first translated into code for a stack machine and then a non-standard interpreter applied to this code checks (or infers) the type of the corresponding values. This can be seen as an abstract interpretation of the object code of the program